// 全局错误处理和日志记录工具

class Logger {
  constructor() {
    this.logs = [];
    this.maxLogs = 100; // 最大日志数量
    this.logLevel = 'info'; // 日志级别: debug, info, warn, error
  }
  
  /**
   * 记录调试日志
   * @param {string} message - 日志消息
   * @param {any} data - 附加数据
   */
  debug(message, data = null) {
    if (this.shouldLog('debug')) {
      this.log('debug', message, data);
    }
  }
  
  /**
   * 记录信息日志
   * @param {string} message - 日志消息
   * @param {any} data - 附加数据
   */
  info(message, data = null) {
    if (this.shouldLog('info')) {
      this.log('info', message, data);
    }
  }
  
  /**
   * 记录警告日志
   * @param {string} message - 日志消息
   * @param {any} data - 附加数据
   */
  warn(message, data = null) {
    if (this.shouldLog('warn')) {
      this.log('warn', message, data);
    }
  }
  
  /**
   * 记录错误日志
   * @param {string} message - 日志消息
   * @param {any} error - 错误对象
   */
  error(message, error = null) {
    if (this.shouldLog('error')) {
      this.log('error', message, error);
    }
  }
  
  /**
   * 记录日志
   * @param {string} level - 日志级别
   * @param {string} message - 日志消息
   * @param {any} data - 附加数据
   */
  log(level, message, data = null) {
    const logEntry = {
      timestamp: new Date().toISOString(),
      level,
      message,
      data
    };
    
    // 添加到日志数组
    this.logs.push(logEntry);
    
    // 保持日志数量在限制范围内
    if (this.logs.length > this.maxLogs) {
      this.logs.shift();
    }
    
    // 输出到控制台
    const consoleMessage = `[${logEntry.timestamp}] ${level.toUpperCase()}: ${message}`;
    switch (level) {
      case 'debug':
        console.debug(consoleMessage, data);
        break;
      case 'info':
        console.info(consoleMessage, data);
        break;
      case 'warn':
        console.warn(consoleMessage, data);
        break;
      case 'error':
        console.error(consoleMessage, data);
        break;
      default:
        console.log(consoleMessage, data);
    }
  }
  
  /**
   * 判断是否应该记录指定级别的日志
   * @param {string} level - 日志级别
   * @returns {boolean} 是否应该记录
   */
  shouldLog(level) {
    const levels = ['debug', 'info', 'warn', 'error'];
    return levels.indexOf(level) >= levels.indexOf(this.logLevel);
  }
  
  /**
   * 设置日志级别
   * @param {string} level - 日志级别
   */
  setLogLevel(level) {
    const validLevels = ['debug', 'info', 'warn', 'error'];
    if (validLevels.includes(level)) {
      this.logLevel = level;
    } else {
      this.warn('Invalid log level', { level });
    }
  }
  
  /**
   * 获取所有日志
   * @returns {Array} 日志数组
   */
  getLogs() {
    return this.logs;
  }
  
  /**
   * 清空日志
   */
  clearLogs() {
    this.logs = [];
  }
  
  /**
   * 将日志导出为文本
   * @returns {string} 日志文本
   */
  exportLogs() {
    return this.logs.map(log => 
      `[${log.timestamp}] ${log.level.toUpperCase()}: ${log.message} ${log.data ? JSON.stringify(log.data) : ''}`
    ).join('\n');
  }
  
  /**
   * 保存日志到本地存储
   */
  saveLogs() {
    try {
      uni.setStorageSync('app_logs', this.logs);
    } catch (e) {
      console.error('Failed to save logs to storage', e);
    }
  }
  
  /**
   * 从本地存储加载日志
   */
  loadLogs() {
    try {
      const logs = uni.getStorageSync('app_logs');
      if (logs) {
        this.logs = logs;
      }
    } catch (e) {
      console.error('Failed to load logs from storage', e);
    }
  }
}

// 创建全局日志实例
const logger = new Logger();

// 全局错误处理
function setupGlobalErrorHandler() {
  // 捕获未处理的JavaScript异常
  if (typeof window !== 'undefined') {
    window.addEventListener('error', (event) => {
      logger.error('Unhandled JavaScript error', {
        message: event.message,
        filename: event.filename,
        lineno: event.lineno,
        colno: event.colno,
        error: event.error
      });
    });
    
    window.addEventListener('unhandledrejection', (event) => {
      logger.error('Unhandled Promise rejection', {
        reason: event.reason,
        promise: event.promise
      });
    });
  }
  
  // 捕获Vue错误
  if (typeof Vue !== 'undefined') {
    Vue.config.errorHandler = (err, vm, info) => {
      logger.error('Vue error', {
        error: err,
        component: vm ? vm.$options.name : 'Unknown',
        info
      });
    };
    
    Vue.config.warnHandler = (msg, vm, trace) => {
      logger.warn('Vue warning', {
        message: msg,
        component: vm ? vm.$options.name : 'Unknown',
        trace
      });
    };
  }
}

// 初始化全局错误处理
setupGlobalErrorHandler();

export default logger;
export { Logger, setupGlobalErrorHandler };